package com.example.train_operate.service.impl;

import com.example.train_operate.service.OnlineUserService;
import com.example.train_operate.ws.model.OnlineUser;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.web.socket.WebSocketSession;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

/**
 * @author 21609
 */
@Service
@Slf4j
public class OnlineUserServiceImpl implements OnlineUserService {

    // sessionId -> OnlineUser
    private final Map<String, OnlineUser> onlineUsersBySession = new ConcurrentHashMap<>();

    // userId -> OnlineUser
    private final Map<String, OnlineUser> onlineUsersByUserId = new ConcurrentHashMap<>();

    /**
     * 用户上线
     */
    @Override
    public void userOnline(String userId, String userName, String displayName, String deviceType, WebSocketSession session) {
        String sessionId = session.getId();
        OnlineUser onlineUser = new OnlineUser(
                userId, userName, displayName, sessionId, deviceType, session
        );
        onlineUsersBySession.put(sessionId, onlineUser);
        onlineUsersByUserId.put(userId, onlineUser);
        log.info("用户{}上线", onlineUser);
    }

    /**
     * 用户下线
     */
    @Override
    public void userOffline(String sessionId) {
        OnlineUser user = onlineUsersByUserId.remove(sessionId);
        if(user != null){
            onlineUsersByUserId.remove(user.getUserId());
            log.info("用户{}下线", user);
        }
    }

    /**
     * 通过sessionId获取在线用户
     */
    @Override
    public Optional<OnlineUser> getBySessionId(String sessionId) {
        return Optional.ofNullable(onlineUsersBySession.get(sessionId));
    }

    /**
     * 通过userId获取在线用户
     */
    @Override
    public Optional<OnlineUser> getByUserId(String userId) {
        return Optional.ofNullable(onlineUsersByUserId.get(userId));
    }

    /**
     * 获取所有在线用户
     */
    @Override
    public List<OnlineUser> getAllOnlineUsers() {
        return new ArrayList<>(onlineUsersByUserId.values());
    }

    /**
     * 获取指定类型的在线用户
     */
    @Override
    public List<OnlineUser> getOnlineUserByDeviceType(String deviceType) {
        return onlineUsersByUserId.values().stream()
                .filter(user -> user.getDeviceType().equals(deviceType))
                .collect(Collectors.toList());
    }

    /**
     * 更新用户最后活跃时间
     */
    @Override
    public void updateLastActive(String sessionId) {
        OnlineUser user = onlineUsersBySession.get(sessionId);
        if(user != null){
            user.updateLastActive();
        }
    }

    /**
     * 设置用户呼叫状态
     */
    @Override
    public void setCallStatus(String userId, String status) {
        OnlineUser user = onlineUsersByUserId.get(userId);
        if(user != null){
            user.setCallStatus(status);
            log.info("用户{}的呼叫状态已更新为{}", userId, status);
        }
    }

    /**
     * 获取用户呼叫状态
     */
    public String getCallStatus(String userId){
        OnlineUser user = onlineUsersByUserId.get(userId);
        return user != null ? user.getCallStatus() : "OFFLINE";
    }

    /**
     * 检查用户是否在线
     */
    public boolean isUserOnline(String userId){
        return onlineUsersByUserId.containsKey(userId);
    }

    /**
     * 获取当前在线用户数量
     */
    public int getOnlineUserCount(){
        return onlineUsersByUserId.size();
    }

    /**
     * 清理不活跃的用户
     * @param maxInactiveSeconds
     */
    public void cleanInactiveUsers(long maxInactiveSeconds){
        Instant threshold = Instant.now().minusSeconds(maxInactiveSeconds);

        List<String> inactiveSessionIds = onlineUsersBySession.values().stream()
                .filter(user -> user.getLastActive().isBefore(threshold))
                .map(OnlineUser::getSessionId)
                .collect(Collectors.toList());
        inactiveSessionIds.forEach(this::userOffline);
    }





}
